package Creational.StaticFactory;

import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.XMLConfiguration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


//这个模式本身很简单而且使用在业务较简单的情况下。一般用于小项目或者具体产品很少扩展的情况（这样工厂类才不用经常更改）。
//它由三种角色组成：
//工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，根据逻辑不同，产生具体的工厂产品。如例子中的Driver类。
//抽象产品角色：它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类来实现。如例中的Car接口。
//具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现，如例子中的Benz、Bmw类。

//简单工厂：全部事情一个地方做完
// 工厂模式：创建框架，子类决定如何实现

//1）简单工厂模式为何要用静态方法
//静态方法/变量为所有对象共有的方法/变量，如果某方法/变量与对象无关，可以考虑使用静态方法/变量。
// 用静态方法之后，就不用初始化工厂而直接得到产品。


//静态工厂类
public class FruitFactory {

    private static Logger logger = LoggerFactory.getLogger(FruitFactory.class);

    private FruitFactory(){}

    //    通过匹配参数获取对象
    public static Fruit createFruit(String name){
        if (name.equalsIgnoreCase("Apple")){
            Fruit fruit = new Apple();
            return fruit;
        }else if (name.equalsIgnoreCase("banana")){
            Fruit fruit = new Banana();
            return fruit;
        }else if (name.equalsIgnoreCase("orange")){
            Fruit fruit = new Orange();
            return fruit;
        }else {
            logger.debug("没有这种水果");
            return null;
        }

    }
    //    通过匹配参数获取对象
    public static Fruit createFruitS(String name){
        switch (name){
            case "apple":
                Fruit apple = new Apple();
                return apple;
            case "banana":
                Fruit banana = new Banana();
                return banana;
            case "orange":
                Fruit orange = new Orange();
                return orange;
            default:
                logger.debug("没有找到这种水果");
                return null;
        }
    }

    //    通过配置文件获取对象
    public static Fruit createFruitForXML(){
        String name = "";
        Fruit fruit;
        try {
            XMLConfiguration xmlConfiguration = new XMLConfiguration("fruit.xml");
            name = xmlConfiguration.getString("fruit.name");
        } catch (ConfigurationException e) {
            e.printStackTrace();
        }
        switch (name){
            case "apple":
                fruit = new Apple();
                break;
            case "banana":
                fruit = new Banana();
                break;
            case "orange":
                fruit = new Orange();
                break;
            default:
                logger.debug("没有找到！");
                fruit = null;
                break;
        }
        return fruit;
    }

    //    通过反射匹配对象
    public static <T> T createFruitT(Class<T> cls){
        T t = null;
        try {

            t = (T) Class.forName(cls.getName()).newInstance();

        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            logger.debug("Exception {}",e);
            e.printStackTrace();
        }
        return t;
    }

}



